﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class GameplayPVESurvivorSurvivorManagerWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(Gameplay.PVE.Survivor.SurvivorManager);
			Utils.BeginObjectRegister(type, L, translator, 0, 14, 1, 1);
			
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMissionId", _m_SetMissionId);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReStart", _m_ReStart);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Resume", _m_Resume);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeckToBattle", _m_DeckToBattle);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "FinishShowTask", _m_FinishShowTask);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Win", _m_Win);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Lose", _m_Lose);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SwitchToRpg", _m_SwitchToRpg);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowGuideDialogue", _m_ShowGuideDialogue);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowTruckTips", _m_ShowTruckTips);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeHero", _m_ChangeHero);
			
			
			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Root", _g_get_Root);
            
			Utils.RegisterFunc(L, Utils.SETTER_IDX, "Root", _s_set_Root);
            
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 29, 28);
			
			
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isProfiler", _g_get_isProfiler);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isTest", _g_get_isTest);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isNoDamage", _g_get_isNoDamage);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "selfNoDamage", _g_get_selfNoDamage);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "selfDamageUp", _g_get_selfDamageUp);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isUnitRendering", _g_get_isUnitRendering);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isNavmeshActive", _g_get_isNavmeshActive);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "skipTimeline", _g_get_skipTimeline);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isNavMesh", _g_get_isNavMesh);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isShowEffect", _g_get_isShowEffect);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isMap", _g_get_isMap);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_isLoadgingTest", _g_get_m_isLoadgingTest);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isMissionActive", _g_get_isMissionActive);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isEventActive", _g_get_isEventActive);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isInteractableActive", _g_get_isInteractableActive);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "useMissionHero", _g_get_useMissionHero);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "showCollision", _g_get_showCollision);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isForceDeck", _g_get_isForceDeck);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "testSpawnGroupId", _g_get_testSpawnGroupId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "stageId", _g_get_stageId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "stageSubId", _g_get_stageSubId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "initialHeroes", _g_get_initialHeroes);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dropGravity", _g_get_dropGravity);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dropStartHeight", _g_get_dropStartHeight);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dropFlyTime", _g_get_dropFlyTime);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dropSpeed", _g_get_dropSpeed);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsInGame", _g_get_IsInGame);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isProfiling", _g_get_isProfiling);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isProfiler", _s_set_isProfiler);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isTest", _s_set_isTest);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isNoDamage", _s_set_isNoDamage);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "selfNoDamage", _s_set_selfNoDamage);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "selfDamageUp", _s_set_selfDamageUp);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isUnitRendering", _s_set_isUnitRendering);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isNavmeshActive", _s_set_isNavmeshActive);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "skipTimeline", _s_set_skipTimeline);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isNavMesh", _s_set_isNavMesh);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isShowEffect", _s_set_isShowEffect);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isMap", _s_set_isMap);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_isLoadgingTest", _s_set_m_isLoadgingTest);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isMissionActive", _s_set_isMissionActive);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isEventActive", _s_set_isEventActive);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isInteractableActive", _s_set_isInteractableActive);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "useMissionHero", _s_set_useMissionHero);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "showCollision", _s_set_showCollision);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isForceDeck", _s_set_isForceDeck);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "testSpawnGroupId", _s_set_testSpawnGroupId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "stageId", _s_set_stageId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "stageSubId", _s_set_stageSubId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "initialHeroes", _s_set_initialHeroes);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "dropGravity", _s_set_dropGravity);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "dropStartHeight", _s_set_dropStartHeight);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "dropFlyTime", _s_set_dropFlyTime);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "dropSpeed", _s_set_dropSpeed);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsInGame", _s_set_IsInGame);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "isProfiling", _s_set_isProfiling);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new Gameplay.PVE.Survivor.SurvivorManager();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Survivor.SurvivorManager constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new Gameplay.PVE.Survivor.SurvivorManager();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Survivor.SurvivorManager constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMissionId(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    int _missionId = LuaAPI.xlua_tointeger(L, 2);
                    int _subId = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.SetMissionId( _missionId, _subId );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _missionId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SetMissionId( _missionId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Survivor.SurvivorManager.SetMissionId!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Initialize(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Initialize(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReStart(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ReStart(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Dispose(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Dispose(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Pause(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Pause(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Resume(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Resume(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DeckToBattle(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.DeckToBattle(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FinishShowTask(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.FinishShowTask(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Win(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Win(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Lose(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Lose(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchToRpg(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _levelId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SwitchToRpg( _levelId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowGuideDialogue(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable<System.Action>(L, 3)) 
                {
                    int _dialogueId = LuaAPI.xlua_tointeger(L, 2);
                    System.Action _callback = translator.GetDelegate<System.Action>(L, 3);
                    
                    gen_to_be_invoked.ShowGuideDialogue( _dialogueId, _callback );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _dialogueId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.ShowGuideDialogue( _dialogueId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Survivor.SurvivorManager.ShowGuideDialogue!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowTruckTips(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isShow = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.ShowTruckTips( _isShow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ChangeHero(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ChangeHero(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isProfiler(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isProfiler);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Instance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.Survivor.SurvivorManager.Instance);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Root(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.Root);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isTest(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isTest);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isNoDamage(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isNoDamage);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selfNoDamage(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.selfNoDamage);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selfDamageUp(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.selfDamageUp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isUnitRendering(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isUnitRendering);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isNavmeshActive(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isNavmeshActive);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skipTimeline(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.skipTimeline);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isNavMesh(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isNavMesh);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isShowEffect(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isShowEffect);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMap(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isMap);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_isLoadgingTest(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.m_isLoadgingTest);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMissionActive(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isMissionActive);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isEventActive(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isEventActive);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInteractableActive(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isInteractableActive);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_useMissionHero(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.useMissionHero);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_showCollision(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.showCollision);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isForceDeck(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isForceDeck);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_testSpawnGroupId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.Survivor.SurvivorManager.testSpawnGroupId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_stageId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.Survivor.SurvivorManager.stageId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_stageSubId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, Gameplay.PVE.Survivor.SurvivorManager.stageSubId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_initialHeroes(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Gameplay.PVE.Survivor.SurvivorManager.initialHeroes);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dropGravity(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.Survivor.SurvivorManager.dropGravity);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dropStartHeight(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.Survivor.SurvivorManager.dropStartHeight);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dropFlyTime(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.Survivor.SurvivorManager.dropFlyTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dropSpeed(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, Gameplay.PVE.Survivor.SurvivorManager.dropSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsInGame(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.IsInGame);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isProfiling(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, Gameplay.PVE.Survivor.SurvivorManager.isProfiling);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isProfiler(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isProfiler = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Root(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Survivor.SurvivorManager gen_to_be_invoked = (Gameplay.PVE.Survivor.SurvivorManager)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Root = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isTest(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isTest = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isNoDamage(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isNoDamage = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selfNoDamage(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.selfNoDamage = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selfDamageUp(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.selfDamageUp = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isUnitRendering(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isUnitRendering = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isNavmeshActive(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isNavmeshActive = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skipTimeline(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.skipTimeline = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isNavMesh(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isNavMesh = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isShowEffect(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isShowEffect = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMap(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isMap = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_isLoadgingTest(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.m_isLoadgingTest = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMissionActive(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isMissionActive = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isEventActive(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isEventActive = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInteractableActive(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isInteractableActive = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_useMissionHero(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.useMissionHero = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_showCollision(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.showCollision = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isForceDeck(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isForceDeck = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_testSpawnGroupId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.testSpawnGroupId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_stageId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.stageId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_stageSubId(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.stageSubId = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_initialHeroes(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Gameplay.PVE.Survivor.SurvivorManager.initialHeroes = (System.Collections.Generic.List<int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_dropGravity(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.dropGravity = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_dropStartHeight(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.dropStartHeight = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_dropFlyTime(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.dropFlyTime = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_dropSpeed(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.dropSpeed = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsInGame(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.IsInGame = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isProfiling(RealStatePtr L)
        {
		    try {
                
			    Gameplay.PVE.Survivor.SurvivorManager.isProfiling = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
